FastAPI தரவுத்தள ஒருங்கிணைப்பு: ஒரு ஆழமான டைவ் அсинக்ரோனஸ் தரவுத்தள செயல்பாடுகளுக்குள்

நவீன வலை வளர்ச்சியின் உலகில், செயல்திறன் என்பது ஒரு அம்சம் மட்டுமல்ல; இது ஒரு அடிப்படை தேவை. பயனர்கள் வேகமான, பதிலளிக்கக்கூடிய பயன்பாடுகளை எதிர்பார்க்கிறார்கள், மேலும் இந்த எதிர்பார்ப்புகளைப் பூர்த்தி செய்ய டெவலப்பர்கள் தொடர்ந்து கருவிகளையும் நுட்பங்களையும் தேடுகிறார்கள். FastAPI பைதான் சூழலில் ஒரு சக்தியாக உருவெடுத்துள்ளது, அதன் நம்பமுடியாத வேகத்திற்காக கொண்டாடப்படுகிறது, இது பெரும்பாலும் அதன் அсинக்ரோனஸ் தன்மைக்கு நன்றி. இருப்பினும், ஒரு வேகமான கட்டமைப்பு என்பது ஒரு பகுதியே. உங்கள் பயன்பாடு அதன் பெரும்பாலான நேரத்தை மெதுவான தரவுத்தளத்திற்காக காத்திருந்தால், நீங்கள் ஒரு போக்குவரத்து நெரிசலில் சிக்கிய ஒரு உயர்-செயல்திறன் இயந்திரத்தை உருவாக்கியுள்ளீர்கள்.

அங்குதான் அсинக்ரோனஸ் தரவுத்தள செயல்பாடுகள் முக்கியமானவை. உங்கள் FastAPI பயன்பாட்டை முழு செயல்முறையையும் தடுக்காமல் தரவுத்தள வினவல்களைக் கையாள அனுமதிப்பதன் மூலம், நீங்கள் உண்மையான போட்டித்திறனைத் திறந்து, வேகமான மற்றும் அதிக அளவிடக்கூடிய பயன்பாடுகளை உருவாக்கலாம். இந்த விரிவான வழிகாட்டி, FastAPI உடன் அсинக்ரோனஸ் தரவுத்தளங்களை ஒருங்கிணைப்பதற்கான ஏன், என்ன, எப்படி என்பதை உங்களுக்குக் காண்பிக்கும், மேலும் உலகளாவிய பார்வையாளர்களுக்காக உண்மையிலேயே உயர்-செயல்திறன் சேவைகளை உருவாக்க உங்களுக்கு அதிகாரம் அளிக்கும்.

மைய கருத்து: ஏன் அсинக்ரோனஸ் I/O முக்கியம்

குறியீட்டிற்குள் நுழைவதற்கு முன், அсинக்ரோனஸ் செயல்பாடுகள் தீர்க்கும் அடிப்படை சிக்கலைப் புரிந்துகொள்வது முக்கியம்: I/O-bound காத்திருப்பு.

ஒரு சமையலறையில் ஒரு திறமையான சமையல்காரரை கற்பனை செய்து பாருங்கள். ஒரு ஒத்திசைவான (அல்லது தடுக்கும்) மாதிரியில், இந்த சமையல்காரர் ஒரு நேரத்தில் ஒரு பணியைச் செய்வார். அவர்கள் தண்ணீரை கொதிக்க வைப்பதற்காக அடுப்பில் வைப்பார்கள், மேலும் அது கொதிக்கும் வரை அங்கேயே நின்று அதைப் பார்ப்பார்கள். தண்ணீர் கொதித்த பிறகுதான் அவர்கள் காய்கறிகளை நறுக்கச் செல்வார்கள். இது நம்பமுடியாத அளவிற்கு திறமையற்றது. சமையல்காரரின் நேரம் (CPU) காத்திருப்பு காலத்தில் வீணாகிறது (I/O செயல்பாடு).

இப்போது, ஒரு அсинக்ரோனஸ் (தடுக்காத) மாதிரியைக் கவனியுங்கள். சமையல்காரர் தண்ணீரை கொதிக்க வைக்கிறார், மேலும் காத்திருப்பதற்கு பதிலாக, உடனடியாக காய்கறிகளை நறுக்க ஆரம்பிக்கிறார். அவர்கள் அடுப்பில் ஒரு தட்டை வைக்கலாம். மெதுவான செயல்பாடுகள் (கொதிக்கும் தண்ணீர் அல்லது பேக்கிங் போன்றவை) முடிவடையும் வரை அவர்கள் பல முன்னணிகளில் முன்னேற்றம் அடைந்து பணிகளை மாற்றலாம். ஒரு பணி முடிந்ததும் (தண்ணீர் கொதிக்கிறது), சமையல்காரருக்கு அறிவிக்கப்பட்டு, அந்த டிஷ்ஷிற்கான அடுத்த கட்டத்திற்குச் செல்லலாம்.

ஒரு வலைப் பயன்பாட்டில், தரவுத்தள வினவல்கள், API அழைப்புகள் மற்றும் கோப்புகளைப் படித்தல் ஆகியவை தண்ணீரை கொதிக்க வைப்பதற்கு சமமானவை. ஒரு பாரம்பரிய ஒத்திசைவான பயன்பாடு ஒரு கோரிக்கையைச் செயல்படுத்தும், தரவுத்தளத்திற்கு ஒரு வினவலை அனுப்பும், பின்னர் தரவுத்தளம் பதிலளிக்கும் வரை மற்ற எந்த உள்வரும் கோரிக்கைகளையும் தடுக்கும். பைத்தானின் `asyncio` மற்றும் FastAPI போன்ற கட்டமைப்புகளால் இயக்கப்படும் ஒரு அсинக்ரோனஸ் பயன்பாடு, I/O க்காகக் காத்திருக்கும்போதெல்லாம் அவற்றை திறமையாக மாற்றுவதன் மூலம் ஆயிரக்கணக்கான ஒரே நேரத்தில் இணைப்புகளைக் கையாள முடியும்.

Async தரவுத்தள செயல்பாடுகளின் முக்கிய நன்மைகள்:

• அதிகரித்த போட்டித்தன்மை: ஒரே வன்பொருள் வளங்களைக் கொண்டு ஒரே நேரத்தில் அதிக எண்ணிக்கையிலான பயனர்களைக் கையாளவும்.
• மேம்படுத்தப்பட்ட த்ரூபுட்: தரவுத்தளத்திற்காகக் காத்திருப்பதில் பயன்பாடு சிக்கிக் கொள்ளாததால், ஒரு வினாடிக்கு அதிக கோரிக்கைகளைக் கையாளவும்.
• மேம்படுத்தப்பட்ட பயனர் அனுபவம்: வேகமான பதில் நேரங்கள், இறுதிப் பயனருக்கு மிகவும் பதிலளிக்கக்கூடிய மற்றும் திருப்திகரமான அனுபவத்திற்கு வழிவகுக்கும்.
• வளத்திறன்: CPU மற்றும் நினைவகத்தின் சிறந்த பயன்பாடு, இது உள்கட்டமைப்பு செலவுகளைக் குறைக்க வழிவகுக்கும்.

உங்கள் அсинக்ரோனஸ் மேம்பாட்டு சூழலை அமைத்தல்

தொடங்குவதற்கு, உங்களுக்கு சில முக்கிய கூறுகள் தேவைப்படும். இந்த எடுத்துக்காட்டுகளுக்காக PostgreSQL ஐ எங்கள் தரவுத்தளமாகப் பயன்படுத்துவோம், ஏனெனில் இது அсинக்ரோனஸ் டிரைவர்களுக்கு சிறந்த ஆதரவைக் கொண்டுள்ளது. இருப்பினும், கொள்கைகள் MySQL மற்றும் SQLite போன்ற மற்ற தரவுத்தளங்களுக்கும் பொருந்தும்.

1. கோர் கட்டமைப்பு மற்றும் சர்வர்

முதலில், FastAPI மற்றும் Uvicorn போன்ற ASGI சேவையகத்தை நிறுவவும்.

            pip install fastapi uvicorn[standard]
            

              
                Copy
              
            
          

2. உங்கள் Async தரவுத்தள கருவியை தேர்ந்தெடுத்தல்

உங்கள் தரவுத்தளத்துடன் அсинக்ரோனஸாகப் பேச உங்களுக்கு இரண்டு முக்கிய கூறுகள் தேவை:

1. ஒரு Async தரவுத்தள இயக்கி: இது ஒரு குறைந்த-நிலை நூலகமாகும், இது அсинக்ரோனஸ் நெறிமுறையைப் பயன்படுத்தி நெட்வொர்க்கில் தரவுத்தளத்துடன் தொடர்பு கொள்கிறது. PostgreSQLக்கு, asyncpg என்பது நடைமுறையில் உள்ள தரநிலையாகும், மேலும் இது நம்பமுடியாத செயல்திறனுக்காக அறியப்படுகிறது.
2. ஒரு Async வினவல் பில்டர் அல்லது ORM: இது உங்கள் வினவல்களை எழுத ஒரு உயர்-நிலை, மேலும் பைத்தானிக் வழியை வழங்குகிறது. இரண்டு பிரபலமான விருப்பங்களை ஆராய்வோம்:
   • databases: மூல SQL செயலாக்கத்திற்கான ஒரு சுத்தமான API ஐ வழங்கும், ஒரு எளிய, இலகுரக async வினவல் பில்டர்.
   • SQLAlchemy 2.0+: சக்திவாய்ந்த மற்றும் அம்சம் நிறைந்த SQLAlchemy ORM இன் சமீபத்திய பதிப்புகள் `asyncio` க்கான சொந்த, முதல்-வகுப்பு ஆதரவை உள்ளடக்குகின்றன. சிக்கலான பயன்பாடுகளுக்கு இது பெரும்பாலும் விருப்பமான தேர்வாகும்.

3. நிறுவல்

அவசியமான நூலகங்களை நிறுவுவோம். நீங்கள் கருவிகளில் ஒன்றை தேர்வு செய்யலாம் அல்லது பரிசோதனை செய்ய இரண்டையும் நிறுவலாம்.

SQLAlchemy மற்றும் `databases` உடன் PostgreSQL க்கு:

            # Driver for PostgreSQL
pip install asyncpg

# For the SQLAlchemy 2.0+ approach
pip install sqlalchemy

# For the 'databases' library approach
pip install databases[postgresql]
            

              
                Copy
              
            
          

எங்கள் சூழல் தயாராக இருப்பதால், இந்த கருவிகளை FastAPI பயன்பாட்டில் எவ்வாறு ஒருங்கிணைப்பது என்பதை ஆராய்வோம்.

உத்தி 1: `databases` நூலகத்துடன் எளிமை

databases நூலகம் ஒரு சிறந்த ஆரம்ப புள்ளியாகும். இது எளிமையாக வடிவமைக்கப்பட்டுள்ளது மற்றும் அடிப்படை async டிரைவர்களுடன் ஒரு மெல்லிய ரேப்பரை வழங்குகிறது, மூல SQL இன் சக்தியை முழு ORM இன் சிக்கல் இல்லாமல் உங்களுக்கு வழங்குகிறது.

படி 1: தரவுத்தள இணைப்பு மற்றும் லைஃப் சைக்கிள் மேனேஜ்மென்ட்

உண்மையான பயன்பாட்டில், ஒவ்வொரு கோரிக்கையிலும் தரவுத்தளத்திலிருந்து இணைக்கவோ அல்லது துண்டிக்கவோ நீங்கள் விரும்ப மாட்டீர்கள். இது திறமையற்றது. அதற்கு பதிலாக, பயன்பாடு தொடங்கும் போது ஒரு இணைப்பு பூலை நிறுவுவோம், மேலும் அது மூடும்போது அதை நேர்த்தியாக மூடுவோம். FastAPI இன் நிகழ்வு கையாளுபவர்கள் (`@app.on_event("startup")` மற்றும் `@app.on_event("shutdown")`) இதற்கு ஏற்றது.

main_databases.py என்ற பெயரில் ஒரு கோப்பை உருவாக்குவோம்:

            import databases
import sqlalchemy
from fastapi import FastAPI

# --- Database Configuration ---
# Replace with your actual database URL
# Format for asyncpg: "postgresql+asyncpg://user:password@host/dbname"
DATABASE_URL = "postgresql+asyncpg://user:password@localhost/testdb"

database = databases.Database(DATABASE_URL)

# SQLAlchemy model metadata (for table creation)
metadata = sqlalchemy.MetaData()

# Define a sample table
notes = sqlalchemy.Table(
    "notes",
    metadata,
    sqlalchemy.Column("id", sqlalchemy.Integer, primary_key=True),
    sqlalchemy.Column("title", sqlalchemy.String(100)),
    sqlalchemy.Column("content", sqlalchemy.String(500)),
)

# Create an engine for table creation (this part is synchronous)
# The 'databases' library doesn't handle schema creation
engine = sqlalchemy.create_engine(DATABASE_URL.replace("+asyncpg", ""))
metadata.create_all(engine)

# --- FastAPI Application ---
app = FastAPI(title="FastAPI with Databases Library")

@app.on_event("startup")
async def startup():
    print("Connecting to database...")
    await database.connect()
    print("Database connection established.")

@app.on_event("shutdown")
async def shutdown():
    print("Disconnecting from database...")
    await database.disconnect()
    print("Database connection closed.")

# --- API Endpoints ---
@app.get("/")
def read_root():
    return {"message": "Welcome to the Async Database API!"}

            

              
                Copy
              
            
          

முக்கிய புள்ளிகள்:

• நாங்கள் postgresql+asyncpg திட்டத்தைப் பயன்படுத்தி DATABASE_URL ஐ வரையறுக்கிறோம்.
• ஒரு உலகளாவிய database பொருள் உருவாக்கப்பட்டது.
• startup நிகழ்வு கையாளுபவர் await database.connect() ஐ அழைக்கிறார், இது இணைப்பு பூலை துவக்குகிறது.
• shutdown நிகழ்வு கையாளுபவர் அனைத்து இணைப்புகளையும் சுத்தமாக மூட await database.disconnect() ஐ அழைக்கிறார்.

படி 2: அсинக்ரோனஸ் CRUD எண்ட்பாயிண்ட்களை செயல்படுத்துதல்

இப்போது, உருவாக்கவும், படிக்கவும், புதுப்பிக்கவும் மற்றும் நீக்கவும் (CRUD) செயல்பாடுகளைச் செய்ய எண்ட்பாயிண்ட்களைச் சேர்ப்போம். தரவு சரிபார்ப்பு மற்றும் தொடர் வரிசைப்படுத்தலுக்கு Pydantic ஐயும் பயன்படுத்துவோம்.

உங்கள் main_databases.py கோப்பில் பின்வருவனவற்றைச் சேர்க்கவும்:

            from pydantic import BaseModel
from typing import List, Optional

# --- Pydantic Models for data validation ---
class NoteIn(BaseModel):
    title: str
    content: str

class Note(BaseModel):
    id: int
    title: str
    content: str

# --- CRUD Endpoints ---

@app.post("/notes/", response_model=Note)
async def create_note(note: NoteIn):
    """Create a new note in the database."""
    query = notes.insert().values(title=note.title, content=note.content)
    last_record_id = await database.execute(query)
    return {**note.dict(), "id": last_record_id}

@app.get("/notes/", response_model=List[Note])
async def read_all_notes():
    """Retrieve all notes from the database."""
    query = notes.select()
    return await database.fetch_all(query)

@app.get("/notes/{note_id}", response_model=Note)
async def read_note(note_id: int):
    """Retrieve a single note by its ID."""
    query = notes.select().where(notes.c.id == note_id)
    result = await database.fetch_one(query)
    if result is None:
        raise HTTPException(status_code=404, detail="Note not found")
    return result

@app.put("/notes/{note_id}", response_model=Note)
async def update_note(note_id: int, note: NoteIn):
    """Update an existing note."""
    query = (
        notes.update()
        .where(notes.c.id == note_id)
        .values(title=note.title, content=note.content)
    )
    result = await database.execute(query)
    if result == 0:
        raise HTTPException(status_code=404, detail="Note not found")
    return {**note.dict(), "id": note_id}

@app.delete("/notes/{note_id}")
async def delete_note(note_id: int):
    """Delete a note by its ID."""
    query = notes.delete().where(notes.c.id == note_id)
    result = await database.execute(query)
    if result == 0:
        raise HTTPException(status_code=404, detail="Note not found")
    return {"message": "Note deleted successfully"}


            

              
                Copy
              
            
          

Async அழைப்புகளின் பகுப்பாய்வு:

• await database.execute(query): INSERT, UPDATE மற்றும் DELETE போன்ற வரிசைகளை திரும்பத் தராத செயல்பாடுகளுக்குப் பயன்படுத்தப்படுகிறது. இது பாதிக்கப்பட்ட வரிசைகளின் எண்ணிக்கையையோ அல்லது புதிய பதிவின் முதன்மை விசையையோ வழங்குகிறது.
• await database.fetch_all(query): நீங்கள் பல வரிசைகளை எதிர்பார்க்கும் SELECT வினவல்களுக்குப் பயன்படுத்தப்படுகிறது. இது பதிவுகளின் பட்டியலை வழங்குகிறது.
• await database.fetch_one(query): நீங்கள் அதிகபட்சம் ஒரு வரிசையை எதிர்பார்க்கும் SELECT வினவல்களுக்குப் பயன்படுத்தப்படுகிறது. இது ஒரு பதிவை அல்லது None ஐ வழங்குகிறது.

ஒவ்வொரு தரவுத்தள தொடர்பும் await உடன் முன்னொட்டாக இருப்பதைக் கவனிக்கவும். இதுதான் தரவுத்தளம் பதிலளிக்கக் காத்திருக்கும்போது நிகழ்வு சுழற்சி பிற பணிகளுக்கு மாற அனுமதிக்கும் மந்திரம், இது உயர் போட்டித்திறனை செயல்படுத்துகிறது.

உத்தி 2: நவீன பவர்ஹவுஸ் - SQLAlchemy 2.0+ Async ORM

databases நூலகம் எளிமைக்கு சிறந்தது என்றாலும், பல பெரிய அளவிலான பயன்பாடுகள் முழு-அம்சம் கொண்ட ஆப்ஜெக்ட்-ரிலேஷனல் மேப்பர் (ORM) மூலம் பயனடைகின்றன. ஒரு ORM தரவுத்தள பதிவுகளை பைதான் பொருட்களாகப் பயன்படுத்த உங்களை அனுமதிக்கும், இது டெவலப்பர் உற்பத்தித்திறன் மற்றும் குறியீடு பராமரிப்புத்திறனை கணிசமாக மேம்படுத்தும். பைதான் உலகில் SQLAlchemy மிகவும் சக்திவாய்ந்த ORM ஆகும், மேலும் அதன் 2.0+ பதிப்புகள் ஒரு அதிநவீன சொந்த அசிங்க் இடைமுகத்தை வழங்குகின்றன.

படி 1: அசிங்க் இன்ஜின் மற்றும் அமர்வை அமைத்தல்

SQLAlchemy இன் அசிங்க் செயல்பாட்டின் முக்கிய அம்சம் AsyncEngine மற்றும் AsyncSession இல் உள்ளது. அமைவு ஒத்திசைவான பதிப்பிலிருந்து சற்று வித்தியாசமானது.

சிறந்த அமைப்புக்காக எங்கள் குறியீட்டை சில கோப்புகளில் ஒழுங்கமைப்போம்: database.py, models.py, schemas.py மற்றும் main_sqlalchemy.py.

database.py:

            from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
from sqlalchemy.orm import sessionmaker

DATABASE_URL = "postgresql+asyncpg://user:password@localhost/testdb"

# Create an async engine
engine = create_async_engine(DATABASE_URL, echo=True)

# Create a session factory
# expire_on_commit=False prevents attributes from being expired after commit
AsyncSessionLocal = sessionmaker(
    bind=engine, class_=AsyncSession, expire_on_commit=False
)

            

              
                Copy
              
            
          

models.py:

            from sqlalchemy import Column, Integer, String
from sqlalchemy.orm import declarative_base

Base = declarative_base()

class Note(Base):
    __tablename__ = "notes"

    id = Column(Integer, primary_key=True, index=True)
    title = Column(String(100), index=True)
    content = Column(String(500))

            

              
                Copy
              
            
          

schemas.py (Pydantic மாதிரிகள்):

            from pydantic import BaseModel

class NoteBase(BaseModel):
    title: str
    content: str

class NoteCreate(NoteBase):
    pass

class Note(NoteBase):
    id: int

    class Config:
        orm_mode = True

            

              
                Copy
              
            
          

Pydantic மாதிரியின் கட்டமைப்பு வகுப்பில் உள்ள `orm_mode = True` என்பது ஒரு முக்கிய மாயாஜாலத்தின் ஒரு முக்கிய பகுதியாகும். இது Pydantic தரவை அகராதிகளில் இருந்து மட்டுமல்லாமல், ORM மாதிரி பண்புக்கூறுகளிலிருந்தும் படிக்கச் சொல்கிறது.

படி 2: சார்புநிலை ஊசி மூலம் அமர்வுகளை நிர்வகித்தல்

FastAPI இல் தரவுத்தள அமர்வுகளை நிர்வகிப்பதற்கான பரிந்துரைக்கப்பட்ட வழி சார்புநிலை ஊசி மூலம் ஆகும். ஒரு கோரிக்கைக்கு ஒரு தரவுத்தள அமர்வை வழங்கும் மற்றும் பிழை ஏற்பட்டாலும் கூட அதை மூடுவதை உறுதி செய்யும் ஒரு சார்புநிலையை உருவாக்குவோம்.

இதை உங்கள் main_sqlalchemy.py இல் சேர்க்கவும்:

            from fastapi import Depends, FastAPI, HTTPException
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy.future import select

from . import models, schemas
from .database import engine, AsyncSessionLocal

app = FastAPI()

# --- Dependency for getting a DB session ---
async def get_db() -> AsyncSession:
    async with AsyncSessionLocal() as session:
        try:
            yield session
        finally:
            await session.close()

# --- Database Initialization (for creating tables) ---
@app.on_event("startup")
async def startup_event():
    print("Initializing database schema...")
    async with engine.begin() as conn:
        # await conn.run_sync(models.Base.metadata.drop_all)
        await conn.run_sync(models.Base.metadata.create_all)
    print("Database schema initialized.")

            

              
                Copy
              
            
          

get_db சார்புநிலை இந்த முறையின் ஒரு மூலக்கல்லாகும். அதைப் பயன்படுத்தும் ஒரு எண்ட்பாயிண்ட்டுக்கு வரும் ஒவ்வொரு கோரிக்கைக்கும், அது செய்யும்:

1. ஒரு புதிய AsyncSession ஐ உருவாக்குங்கள்.
2. எண்ட்பாயிண்ட் செயல்பாட்டிற்கு அமர்வை yield செய்யுங்கள்.
3. finally பிளாக்கின் உள்ளே உள்ள குறியீடு, கோரிக்கை வெற்றி பெற்றதா இல்லையா என்பதைப் பொருட்படுத்தாமல், அமர்வு மூடப்பட்டு, இணைப்பை பூலுக்குத் திருப்பித் தருவதை உறுதி செய்கிறது.

படி 3: SQLAlchemy ORM உடன் Async CRUD ஐ செயல்படுத்துதல்

இப்போது எங்கள் எண்ட்பாயிண்ட்களை எழுதலாம். அவை மூல SQL அணுகுமுறையை விட சுத்தமாகவும், பொருள் சார்ந்ததாகவும் இருக்கும்.

இந்த எண்ட்பாயிண்ட்களை main_sqlalchemy.py இல் சேர்க்கவும்:

            
@app.post("/notes/", response_model=schemas.Note)
async def create_note(
    note: schemas.NoteCreate, db: AsyncSession = Depends(get_db)
):
    db_note = models.Note(title=note.title, content=note.content)
    db.add(db_note)
    await db.commit()
    await db.refresh(db_note)
    return db_note

@app.get("/notes/", response_model=list[schemas.Note])
async def read_all_notes(skip: int = 0, limit: int = 100, db: AsyncSession = Depends(get_db)):
    result = await db.execute(select(models.Note).offset(skip).limit(limit))
    notes = result.scalars().all()
    return notes

@app.get("/notes/{note_id}", response_model=schemas.Note)
async def read_note(note_id: int, db: AsyncSession = Depends(get_db)):
    result = await db.execute(select(models.Note).filter(models.Note.id == note_id))
    db_note = result.scalar_one_or_none()
    if db_note is None:
        raise HTTPException(status_code=404, detail="Note not found")
    return db_note

@app.put("/notes/{note_id}", response_model=schemas.Note)
async def update_note(
    note_id: int, note: schemas.NoteCreate, db: AsyncSession = Depends(get_db)
):
    result = await db.execute(select(models.Note).filter(models.Note.id == note_id))
    db_note = result.scalar_one_or_none()
    if db_note is None:
        raise HTTPException(status_code=404, detail="Note not found")
    
    db_note.title = note.title
    db_note.content = note.content
    await db.commit()
    await db.refresh(db_note)
    return db_note

@app.delete("/notes/{note_id}")
async def delete_note(note_id: int, db: AsyncSession = Depends(get_db)):
    result = await db.execute(select(models.Note).filter(models.Note.id == note_id))
    db_note = result.scalar_one_or_none()
    if db_note is None:
        raise HTTPException(status_code=404, detail="Note not found")
    
    await db.delete(db_note)
    await db.commit()
    return {"message": "Note deleted successfully"}

            

              
                Copy
              
            
          

SQLAlchemy அசிங்க் பேட்டர்னின் பகுப்பாய்வு:

• db: AsyncSession = Depends(get_db): இது எங்கள் தரவுத்தள அமர்வை எண்ட்பாயிண்ட்டில் செலுத்துகிறது.
• await db.execute(...): வினவல்களை இயக்குவதற்கான முதன்மை முறை இதுவாகும்.
• result.scalars().all() / result.scalar_one_or_none(): வினவல் முடிவிலிருந்து உண்மையான ORM பொருட்களை பிரித்தெடுக்க இந்த முறைகள் பயன்படுத்தப்படுகின்றன.
• db.add(obj): ஒரு பொருளை செருகப்படுவதற்காக நிலைப்படுத்துகிறது.
• await db.commit(): பரிவர்த்தனையை தரவுத்தளத்தில் அсинக்ரோனஸாக உறுதிப்படுத்துகிறது. இது ஒரு முக்கியமான `await` புள்ளி.
• await db.refresh(obj): உறுதிப்படுத்தலுக்குப் பிறகு (தானாக உருவாக்கப்பட்ட ID போன்றவை) தரவுத்தளத்திலிருந்து ஏதேனும் புதிய தரவுகளுடன் பைதான் பொருளை புதுப்பிக்கிறது.

செயல்திறன் கருதுகோள்கள் மற்றும் சிறந்த நடைமுறைகள்

`async` மற்றும் `await` ஐப் பயன்படுத்துவது ஒரு சிறந்த தொடக்கமாக இருக்கிறது, ஆனால் உண்மையிலேயே வலுவான மற்றும் உயர்-செயல்திறன் பயன்பாடுகளை உருவாக்க, இந்த சிறந்த நடைமுறைகளைக் கவனியுங்கள்.

1. இணைப்பு பூலிங்கை புரிந்து கொள்ளுங்கள்

databases மற்றும் SQLAlchemy இன் AsyncEngine இரண்டும் பின்னணியில் ஒரு இணைப்பு பூலை நிர்வகிக்கின்றன. இந்த பூல் திறந்த தரவுத்தள இணைப்புகளின் தொகுப்பை பராமரிக்கிறது, அவை வெவ்வேறு கோரிக்கைகளால் மீண்டும் பயன்படுத்தப்படலாம். இது ஒவ்வொரு வினவலுக்கும் ஒரு புதிய TCP இணைப்பை நிறுவுதல் மற்றும் தரவுத்தளத்துடன் அங்கீகரிப்பதற்கான விலையுயர்ந்த ஓவர்ஹெட்டைத் தவிர்க்கிறது. உங்கள் குறிப்பிட்ட பணிச்சுமைக்காக பூல் அளவை (எ.கா., `pool_size`, `max_overflow`) இயந்திர உள்ளமைவில் மாற்றியமைக்கலாம்.

2. ஒத்திசைவு மற்றும் அசிங்க் தரவுத்தள அழைப்புகளை ஒருபோதும் கலக்காதீர்கள்

மிகவும் முக்கியமான விதி என்னவென்றால், ஒரு `async def` செயல்பாட்டிற்குள் ஒரு ஒத்திசைவான, தடுக்கும் I/O செயல்பாட்டை ஒருபோதும் அழைக்கக்கூடாது. ஒரு நிலையான, ஒத்திசைவான தரவுத்தள அழைப்பு (எ.கா., `psycopg2` ஐ நேரடியாகப் பயன்படுத்துதல்) முழு நிகழ்வு சுழற்சியையும் தடுக்கும், உங்கள் பயன்பாட்டை உறைய வைக்கும் மற்றும் அசிங்கின் நோக்கத்தை தோற்கடிக்கும்.

நீங்கள் கண்டிப்பாக ஒரு ஒத்திசைவான குறியீட்டை இயக்க வேண்டும் என்றால் (ஒருவேளை CPU-bound நூலகம்), நிகழ்வு சுழற்சியைத் தடுப்பதைத் தவிர்க்க FastAPI இன் `run_in_threadpool` ஐப் பயன்படுத்தவும்:

            from fastapi.concurrency import run_in_threadpool

@app.get("/run-sync-task/")
async def run_sync_task():
    # 'some_blocking_io_function' is a regular sync function
    result = await run_in_threadpool(some_blocking_io_function, arg1, arg2)
    return {"result": result}

            

              
                Copy
              
            
          

3. அசிங்க்ரோனஸ் பரிவர்த்தனைகளைப் பயன்படுத்தவும்

ஒரு செயல்பாடு பல தரவுத்தள மாற்றங்களை உள்ளடக்கும்போது அவை ஒன்றாக வெற்றிபெற வேண்டும் அல்லது தோல்வியடைய வேண்டும் (ஒரு அணு செயல்பாடு), நீங்கள் ஒரு பரிவர்த்தனையைப் பயன்படுத்த வேண்டும். இரண்டு நூலகங்களும் ஒரு அசிங்க் சூழல் நிர்வாகி மூலம் இதை ஆதரிக்கின்றன.

`databases` உடன்:

            async def transfer_funds():
    async with database.transaction():
        await database.execute(query_for_debit)
        await database.execute(query_for_credit)

            

              
                Copy
              
            
          

SQLAlchemy உடன்:

            async def transfer_funds(db: AsyncSession = Depends(get_db)):
    async with db.begin(): # This starts a transaction
        # Find accounts
        account_from = ...
        account_to = ...
        # Update balances
        account_from.balance -= 100
        account_to.balance += 100
    # The transaction is automatically committed on exiting the block
    # or rolled back if an exception occurs.

            

              
                Copy
              
            
          

4. உங்களுக்கு தேவையானதை மட்டும் தேர்ந்தெடுக்கவும்

சில நெடுவரிசைகள் மட்டுமே தேவைப்படும்போது `SELECT *` ஐத் தவிர்க்கவும். நெட்வொர்க்கில் குறைந்த தரவை அனுப்புவது I/O காத்திருப்பு நேரத்தைக் குறைக்கிறது. SQLAlchemy உடன், நீங்கள் பெற வேண்டிய நெடுவரிசைகளை குறிப்பிட `options(load_only(model.col1, model.col2))` ஐப் பயன்படுத்தலாம்.

முடிவு: அசிங்க்ரோனஸ் எதிர்காலத்தை ஏற்றுக்கொள்

உங்கள் FastAPI பயன்பாட்டில் அசிங்க்ரோனஸ் தரவுத்தள செயல்பாடுகளை ஒருங்கிணைப்பது அதன் முழு செயல்திறன் திறனைத் திறப்பதற்கான திறவுகோலாகும். தரவுத்தளத்திற்காகக் காத்திருக்கும்போது உங்கள் பயன்பாடு தடுக்கப்படாமல் இருப்பதை உறுதி செய்வதன் மூலம், நீங்கள் நம்பமுடியாத அளவிற்கு வேகமான, அளவிடக்கூடிய மற்றும் திறமையான சேவைகளை உருவாக்க முடியும், இது ஒரு வியர்வையும் இல்லாமல் உலகளாவிய பயனர் தளத்திற்கு சேவை செய்ய முடியும்.

நாங்கள் இரண்டு சக்திவாய்ந்த உத்திகளை ஆராய்ந்தோம்:

• `databases` நூலகம் SQL எழுதுவதை விரும்பும் மற்றும் எளிய, வேகமான அசிங்க் இடைமுகம் தேவைப்படும் டெவலப்பர்களுக்கான ஒரு நேரடியான, இலகுரக அணுகுமுறையை வழங்குகிறது.
• SQLAlchemy 2.0+ ஒரு முழு அம்சம் கொண்ட, வலுவான ORM ஐ சொந்த அசிங்க் API உடன் வழங்குகிறது, இது டெவலப்பர் உற்பத்தித்திறன் மற்றும் பராமரிப்புத்திறன் மிக முக்கியமானதாக இருக்கும் சிக்கலான பயன்பாடுகளுக்கு சிறந்த தேர்வாக அமைகிறது.

அவற்றுக்கிடையேயான தேர்வு உங்கள் திட்டத்தின் தேவைகளைப் பொறுத்தது, ஆனால் முக்கிய கொள்கை அப்படியே உள்ளது: தடுக்காததைப் பற்றி சிந்தியுங்கள். இந்த வடிவங்களையும் சிறந்த நடைமுறைகளையும் ஏற்றுக்கொள்வதன் மூலம், நீங்கள் குறியீட்டை எழுதுவது மட்டுமல்ல; நவீன இணையத்தின் உயர்-போட்டித்தன்மைக்கான அமைப்புகளை நீங்கள் வடிவமைக்கிறீர்கள். இன்றே உங்கள் அடுத்த உயர்-செயல்திறன் FastAPI பயன்பாட்டை உருவாக்கத் தொடங்குங்கள் மற்றும் அசிங்க்ரோனஸ் பைத்தானின் சக்தியை நேரடியாக அனுபவிக்கவும்.